home *** CD-ROM | disk | FTP | other *** search
/ Dynamic HTML Construction Kit / Dynamic HTML Construction Kit.iso / earthlink / nscomm / java40.jar / netscape / plugin / composer / io / LexicalStream.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-11-03  |  4.3 KB  |  410 lines
  1. package netscape.plugin.composer.io;
  2.  
  3. import java.io.CharArrayReader;
  4. import java.io.IOException;
  5. import java.io.Reader;
  6.  
  7. public class LexicalStream {
  8.    // $FF: renamed from: in netscape.plugin.composer.io.SlidingBuffer
  9.    private SlidingBuffer field_0;
  10.    private FooStringBuffer buffer;
  11.    private static final String NEWLINE = new String("\n");
  12.    private boolean bHaveClosedStream;
  13.  
  14.    public LexicalStream(String var1) {
  15.       this((Reader)(new CharArrayReader(var1.toCharArray())));
  16.    }
  17.  
  18.    public LexicalStream(Reader var1) {
  19.       this.field_0 = new SlidingBuffer(var1);
  20.    }
  21.  
  22.    private int read() throws IOException {
  23.       return this.field_0.read();
  24.    }
  25.  
  26.    private boolean lookAhead(char var1) throws IOException {
  27.       return this.field_0.lookAhead(var1);
  28.    }
  29.  
  30.    private boolean lookAhead(String var1) throws IOException {
  31.       return this.field_0.lookAhead(var1);
  32.    }
  33.  
  34.    private boolean lookAhead(String var1, boolean var2) throws IOException {
  35.       return this.field_0.lookAhead(var1, var2);
  36.    }
  37.  
  38.    private boolean eatNewline() throws IOException {
  39.       return this.field_0.eatNewline();
  40.    }
  41.  
  42.    private boolean eatWhiteSpace() throws IOException {
  43.       return this.field_0.eatWhiteSpace();
  44.    }
  45.  
  46.    public Token next() throws IOException {
  47.       while(true) {
  48.          int var1 = this.read();
  49.          if (var1 >= 0) {
  50.             if (var1 == 38) {
  51.                if (this.buffer == null) {
  52.                   FooStringBuffer var2 = new FooStringBuffer();
  53.                   this.parseEntity(var2);
  54.                   return new Entity(var2);
  55.                }
  56.  
  57.                this.field_0.unread(1);
  58.             } else if (var1 == 60) {
  59.                if (this.buffer == null) {
  60.                   if (this.field_0.lookAhead('/')) {
  61.                      return this.parseTag(false);
  62.                   }
  63.  
  64.                   if (this.field_0.lookAhead('!')) {
  65.                      return this.parseComment();
  66.                   }
  67.  
  68.                   return this.parseTag(true);
  69.                }
  70.  
  71.                this.field_0.unread(1);
  72.             } else if (var1 == 13) {
  73.                if (this.buffer == null) {
  74.                   this.field_0.lookAhead('\n');
  75.                   return new Text(NEWLINE);
  76.                }
  77.  
  78.                this.field_0.unread(1);
  79.             } else {
  80.                if (var1 != 10) {
  81.                   if (this.buffer == null) {
  82.                      this.buffer = new FooStringBuffer();
  83.                   }
  84.  
  85.                   this.buffer.append((char)var1);
  86.                   continue;
  87.                }
  88.  
  89.                if (this.buffer == null) {
  90.                   return new Text(NEWLINE);
  91.                }
  92.  
  93.                this.field_0.unread(1);
  94.             }
  95.          }
  96.  
  97.          if (this.buffer != null) {
  98.             String var3 = this.buffer.toString();
  99.             this.buffer = null;
  100.             return new Text(var3);
  101.          }
  102.  
  103.          if (!this.bHaveClosedStream) {
  104.             this.field_0.close();
  105.             this.bHaveClosedStream = true;
  106.          }
  107.  
  108.          return null;
  109.       }
  110.    }
  111.  
  112.    private boolean isWhitespace(char var1) {
  113.       return Character.isSpace(var1);
  114.    }
  115.  
  116.    private Token parseTag(boolean var1) throws IOException {
  117.       FooStringBuffer var2 = new FooStringBuffer();
  118.  
  119.       while(true) {
  120.          int var3 = this.read();
  121.          if (var3 < 0 || var3 == 62 || this.isWhitespace((char)var3)) {
  122.             if (var2.length() == 0) {
  123.                var2.append('<');
  124.                if (!var1) {
  125.                   var2.append('/');
  126.                }
  127.  
  128.                if (var3 >= 0) {
  129.                   var2.append((char)var3);
  130.                }
  131.  
  132.                return new Text(var2.toString());
  133.             } else {
  134.                Tag var4 = new Tag(var2.toString(), var1);
  135.                if (var3 == 62) {
  136.                   return var4;
  137.                } else {
  138.                   while(true) {
  139.                      var3 = this.read();
  140.                      if (var3 < 0 || var3 == 62) {
  141.                         return var4;
  142.                      }
  143.  
  144.                      if (!this.isWhitespace((char)var3)) {
  145.                         this.field_0.unread(1);
  146.                         this.parseTagAttribute(var4);
  147.                      }
  148.                   }
  149.                }
  150.             }
  151.          }
  152.  
  153.          var2.append((char)var3);
  154.       }
  155.    }
  156.  
  157.    private void parseTagAttribute(Tag var1) throws IOException {
  158.       FooStringBuffer var2 = new FooStringBuffer();
  159.  
  160.       while(true) {
  161.          int var3 = this.read();
  162.          if (var3 < 0) {
  163.             break;
  164.          }
  165.  
  166.          if (var3 == 62 || var3 == 61) {
  167.             this.field_0.unread(1);
  168.             break;
  169.          }
  170.  
  171.          if (this.isWhitespace((char)var3)) {
  172.             break;
  173.          }
  174.  
  175.          var2.append((char)var3);
  176.       }
  177.  
  178.       if (var2.length() != 0) {
  179.          this.eatWhiteSpace();
  180.          int var5 = this.read();
  181.          FooStringBuffer var4 = null;
  182.          if (var5 != 61) {
  183.             this.field_0.unread(1);
  184.          } else {
  185.             this.eatWhiteSpace();
  186.             var5 = this.read();
  187.             if (var5 >= 0) {
  188.                if (var5 == 62) {
  189.                   this.field_0.unread(1);
  190.                } else if (var5 != 39 && var5 != 34) {
  191.                   var4 = new FooStringBuffer();
  192.                   var4.append((char)var5);
  193.  
  194.                   while(true) {
  195.                      var5 = this.read();
  196.                      if (var5 < 0) {
  197.                         break;
  198.                      }
  199.  
  200.                      if (var5 == 62) {
  201.                         this.field_0.unread(1);
  202.                         break;
  203.                      }
  204.  
  205.                      if (this.isWhitespace((char)var5)) {
  206.                         break;
  207.                      }
  208.  
  209.                      var4.append((char)var5);
  210.                   }
  211.                } else {
  212.                   var4 = this.parseQuotedString(var5);
  213.                }
  214.             }
  215.          }
  216.  
  217.          var1.addAttribute(var2.toString(), var4 != null ? var4.toString() : null);
  218.       }
  219.    }
  220.  
  221.    private FooStringBuffer parseQuotedString(int var1) throws IOException {
  222.       FooStringBuffer var2 = new FooStringBuffer();
  223.  
  224.       while(true) {
  225.          int var3 = this.read();
  226.          if (var3 < 0) {
  227.             break;
  228.          }
  229.  
  230.          if (var3 == 38) {
  231.             if (this.field_0.peek() == 123) {
  232.                this.read();
  233.                this.parseJavaScriptEntity(var2);
  234.             } else {
  235.                this.parseEntity(var2);
  236.             }
  237.          } else {
  238.             if (var3 == var1) {
  239.                break;
  240.             }
  241.  
  242.             var2.append((char)var3);
  243.          }
  244.       }
  245.  
  246.       return var2;
  247.    }
  248.  
  249.    private Comment parseComment() throws IOException {
  250.       FooStringBuffer var1 = new FooStringBuffer();
  251.       boolean var2 = false;
  252.       if (this.field_0.lookAhead('-')) {
  253.          if (this.field_0.lookAhead('-')) {
  254.             var2 = true;
  255.          } else {
  256.             var1.append('-');
  257.          }
  258.       }
  259.  
  260.       while(true) {
  261.          int var3 = this.read();
  262.          if (var3 < 0) {
  263.             break;
  264.          }
  265.  
  266.          if (var2) {
  267.             if (var3 == 45 && this.field_0.lookAhead('-')) {
  268.                if (this.field_0.lookAhead('>')) {
  269.                   break;
  270.                }
  271.  
  272.                var1.append("--");
  273.             }
  274.          } else if (var3 == 62) {
  275.             break;
  276.          }
  277.  
  278.          var1.append((char)var3);
  279.       }
  280.  
  281.       return var2 ? new Comment("--" + var1 + "--") : new Comment(var1);
  282.    }
  283.  
  284.    private void parseEntity(FooStringBuffer var1) throws IOException {
  285.       while(true) {
  286.          int var2 = this.read();
  287.          if (var2 < 0 || var2 == 59) {
  288.             return;
  289.          }
  290.  
  291.          if (this.isWhitespace((char)var2)) {
  292.             this.field_0.unread(1);
  293.             return;
  294.          }
  295.  
  296.          var1.append((char)var2);
  297.       }
  298.    }
  299.  
  300.    private void parseJavaScriptEntity(FooStringBuffer var1) throws IOException {
  301.       int var2 = 1;
  302.  
  303.       while(true) {
  304.          int var3 = this.read();
  305.          if (var3 < 0) {
  306.             break;
  307.          }
  308.  
  309.          if (var3 != 39 && var3 != 34) {
  310.             if (var3 == 123) {
  311.                var1.append((char)var3);
  312.                ++var2;
  313.             } else if (var3 == 125) {
  314.                --var2;
  315.                if (var2 == 0) {
  316.                   this.field_0.lookAhead(';');
  317.                   return;
  318.                }
  319.  
  320.                var1.append((char)var3);
  321.             } else if (var3 == 47) {
  322.                var3 = this.read();
  323.                if (var3 < 0) {
  324.                   break;
  325.                }
  326.  
  327.                if (var3 == 42) {
  328.                   this.parseCComment(var1);
  329.                } else if (var3 == 47) {
  330.                   this.parseEOLComment(var1);
  331.                } else {
  332.                   var1.append('/');
  333.                   var1.append((char)var3);
  334.                }
  335.             } else {
  336.                var1.append((char)var3);
  337.             }
  338.          } else {
  339.             this.parseJavaScriptQuotedString(var1, var3);
  340.          }
  341.       }
  342.  
  343.    }
  344.  
  345.    private void parseJavaScriptQuotedString(FooStringBuffer var1, int var2) throws IOException {
  346.       var1.append((char)var2);
  347.  
  348.       while(true) {
  349.          int var3 = this.read();
  350.          if (var3 < 0) {
  351.             break;
  352.          }
  353.  
  354.          var1.append((char)var3);
  355.          if (var3 == 92) {
  356.             var3 = this.read();
  357.             if (var3 < 0) {
  358.                break;
  359.             }
  360.  
  361.             var1.append((char)var3);
  362.          } else if (var3 == var2) {
  363.             return;
  364.          }
  365.       }
  366.  
  367.    }
  368.  
  369.    private void parseCComment(FooStringBuffer var1) throws IOException {
  370.       var1.append("/*");
  371.  
  372.       while(true) {
  373.          int var2 = this.read();
  374.          if (var2 < 0) {
  375.             break;
  376.          }
  377.  
  378.          var1.append((char)var2);
  379.          if (var2 == 42) {
  380.             var2 = this.read();
  381.             if (var2 < 0) {
  382.                break;
  383.             }
  384.  
  385.             var1.append((char)var2);
  386.             if (var2 == 47) {
  387.                return;
  388.             }
  389.          }
  390.       }
  391.  
  392.    }
  393.  
  394.    private void parseEOLComment(FooStringBuffer var1) throws IOException {
  395.       var1.append("//");
  396.  
  397.       int var2;
  398.       do {
  399.          var2 = this.read();
  400.          if (var2 < 0) {
  401.             return;
  402.          }
  403.  
  404.          var1.append((char)var2);
  405.       } while(var2 != 10 && var2 != 13);
  406.  
  407.       var1.append((char)var2);
  408.    }
  409. }
  410.